package com.dd.stack.se.stream.concurrent.reentrantlock.readwrite;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Author liuxianmeng
 * @CreateTime 2025/10/5 11:39
 * @Description 基于 ReentrantReadWriteLock 实现的线程安全缓存
 */
public class SafeCache {
    // 底层存储结构
    private final Map<String, Object> cache = new HashMap<>();
    // 读写锁
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    // 读锁（共享锁）
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    // 写锁（独占锁）
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();

    /**
     * 读取缓存（使用读锁，支持并发读）
     */
    public Object get(String key) {
        readLock.lock(); // 获取读锁
        try {
            return cache.get(key); // 多个线程可同时执行
        } finally {
            readLock.unlock(); // 释放读锁（必须在finally中）
        }
    }

    /**
     * 写入缓存（使用写锁，独占执行）
     */
    public void put(String key, Object value) {
        writeLock.lock(); // 获取写锁
        try {
            cache.put(key, value); // 同一时间只有一个线程执行
        } finally {
            writeLock.unlock(); // 释放写锁
        }
    }

    /**
     * 删除缓存（使用写锁，独占执行）
     */
    public void remove(String key) {
        writeLock.lock();
        try {
            cache.remove(key);
        } finally {
            writeLock.unlock();
        }
    }

    /**
     * 清空缓存（使用写锁）
     */
    public void clear() {
        writeLock.lock();
        try {
            cache.clear();
        } finally {
            writeLock.unlock();
        }
    }
}
